\hypertarget{logger_8c}{
\section{/home/noxon/coding/C/esiee-in301/libcomm/logger.c File Reference}
\label{logger_8c}\index{/home/noxon/coding/C/esiee-in301/libcomm/logger.c@{/home/noxon/coding/C/esiee-in301/libcomm/logger.c}}
}
{\tt \#include \char`\"{}logger.h\char`\"{}}\par
\subsection*{Functions}
\begin{CompactItemize}
\item 
int \hyperlink{logger_8c_cc125d9a55592a92f10fc818de33c089}{init\_\-log} (const char $\ast$fn)
\item 
void \hyperlink{logger_8c_5d4e11dc9c0756733a61a76f3e7f57b1}{log\_\-call} (const char $\ast$\hyperlink{structmsg__struct}{msg}, char $\ast$func\_\-name, const char $\ast$args,...)
\item 
void \hyperlink{logger_8c_6cc4eb379baec30531bd4852517f31ad}{log\_\-smth} (const char $\ast$\hyperlink{structmsg__struct}{msg},...)
\item 
void \hyperlink{logger_8c_a7017b21f46168c4c60cfe08a5dba154}{private\_\-log\_\-call} (const char $\ast$\hyperlink{structmsg__struct}{msg}, const char $\ast$func\_\-name, va\_\-list args)
\item 
void \hyperlink{logger_8c_c5780f57248a4e80eb50e695b593a1a0}{private\_\-write\_\-log} (int log\_\-type, const char $\ast$\hyperlink{structmsg__struct}{msg})
\end{CompactItemize}
\subsection*{Variables}
\begin{CompactItemize}
\item 
char $\ast$ \hyperlink{logger_8c_eac90097f29f7529968697163cea5c18}{filename} = NULL
\end{CompactItemize}


\subsection{Function Documentation}
\hypertarget{logger_8c_cc125d9a55592a92f10fc818de33c089}{
\index{logger.c@{logger.c}!init\_\-log@{init\_\-log}}
\index{init\_\-log@{init\_\-log}!logger.c@{logger.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int init\_\-log (const char $\ast$ {\em filename})}}
\label{logger_8c_cc125d9a55592a92f10fc818de33c089}


\begin{Desc}
\item[Author:]Christopher Rabotin. Logger permet de logguer l'activité du programme.\par
 Les méthodes présentes ici permettent d'éviter d'utiliser printf() afin de logguer. -- La fonction de trace est basée sur un code C++: \href{http://www.codeproject.com/KB/cpp/cmtrace.aspx}{\tt http://www.codeproject.com/KB/cpp/cmtrace.aspx} . Permet d'initialiser le fichier de log en vérifiant si le fichier peut-être ouvert en écriture.\par
 Au contraire, un message sera affiché dans stderr si la fonction de log est appelée avec l'init. \end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em $\ast$filename}]nom du fichier \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]0 s'il n'est pas possible d'écrire sur le fichier demandé, 1 sinon. \end{Desc}


Definition at line 5 of file logger.c.

References filename, and log\_\-smth().

Referenced by main().\hypertarget{logger_8c_5d4e11dc9c0756733a61a76f3e7f57b1}{
\index{logger.c@{logger.c}!log\_\-call@{log\_\-call}}
\index{log\_\-call@{log\_\-call}!logger.c@{logger.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void log\_\-call (const char $\ast$ {\em msg}, \/  char $\ast$ {\em func\_\-name}, \/  const char $\ast$ {\em args}, \/   {\em ...})}}
\label{logger_8c_5d4e11dc9c0756733a61a76f3e7f57b1}


Permet de tracer une fonction, avec les paramètres passés, puis appelle \hyperlink{logger_8c_a7017b21f46168c4c60cfe08a5dba154}{private\_\-log\_\-call()}. S'il n'est pas possible d'écrire dans le fichier de log, alors le message de log est affiché dans stdout. Tous les logs concernant les fonctions seront précédées d'un \mbox{[}$\ast$\mbox{]}. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em $\ast$msg}]le message à être loggué \item[{\em $\ast$func\_\-name}]nom de la fonction \item[{\em $\ast$args}]arguments passés à la fonction \item[{\em ...}]signifie qu'il peut y avoir plusieurs arguments. Pour les extraire, on utilisera stdarg.h\end{description}
\end{Desc}
Exemples d'utilisation: \begin{itemize}
\item {\bf Cas général}: log\_\-call(\char`\"{}si erreur, vérifier paramètres\char`\"{}, fct, format, fct\_\-arg1, fct\_\-arg2, fct\_\-arg3); \item {\bf Exemples de TestLogger.c}: \begin{itemize}
\item {\tt log\_\-call(\char`\"{}dans testParamInt\char`\"{}, \char`\"{}testParamInt\char`\"{}, \char`\"{}(\%d,\%d)\char`\"{}, arg1, arg2);} \item {\tt log\_\-call(\char`\"{}dans testParamChar\char`\"{}, \char`\"{}testParamChar\char`\"{}, \char`\"{}($\backslash$\char`\"{}s$\backslash$\char`\"{})\char`\"{}, str);} \item {\tt log\_\-smth(\char`\"{}Okeille c'est bon, l'init est passé youpi!\char`\"{});}\end{itemize}
\end{itemize}


Definition at line 18 of file logger.c.

References private\_\-log\_\-call().

Referenced by create\_\-msg(), and str\_\-to\_\-msg().\hypertarget{logger_8c_6cc4eb379baec30531bd4852517f31ad}{
\index{logger.c@{logger.c}!log\_\-smth@{log\_\-smth}}
\index{log\_\-smth@{log\_\-smth}!logger.c@{logger.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void log\_\-smth (const char $\ast$ {\em msg}, \/   {\em ...})}}
\label{logger_8c_6cc4eb379baec30531bd4852517f31ad}


Permet de logguer un message divers. Tous les logs de messages divers sont précédés d'un \mbox{[}U\mbox{]} \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em msg}]le message à être loggué \item[{\em ...}]permet de s'en servir exactement comme un printf\end{description}
\end{Desc}
Exemples d'utilisation: {\bf Cas général}: log\_\-smth(\char`\"{}test numéro \%d du logguer de nom \%s\char`\"{}, numero, nom);\par
 Exemple de sortie: {\tt \mbox{[}U\mbox{]} $<$2009-01-10 02:59:22$>$ test numéro 2 du logguer de nom LOGGER\_\-UNIQUE} 

Definition at line 28 of file logger.c.

References private\_\-write\_\-log(), and unkown\_\-type.

Referenced by execution(), init\_\-log(), init\_\-module(), launch\_\-acquisition(), launch\_\-execution(), and launch\_\-interboursier().\hypertarget{logger_8c_a7017b21f46168c4c60cfe08a5dba154}{
\index{logger.c@{logger.c}!private\_\-log\_\-call@{private\_\-log\_\-call}}
\index{private\_\-log\_\-call@{private\_\-log\_\-call}!logger.c@{logger.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void private\_\-log\_\-call (const char $\ast$ {\em msg}, \/  const char $\ast$ {\em func\_\-name}, \/  va\_\-list {\em args})}}
\label{logger_8c_a7017b21f46168c4c60cfe08a5dba154}


Permet de logguer l'appel à une fonction, avec des paramètres. Il n'est pas conseillé d'appeler cetter fonction directement! Passez plutôt par \char`\"{}log\char`\"{} qui s'occupe de tout. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em $\ast$msg}]le message à être loggué \item[{\em $\ast$func\_\-name}]nom de la fonction \item[{\em args}]arguments passés à la fonction \end{description}
\end{Desc}


Definition at line 40 of file logger.c.

References call\_\-type, and private\_\-write\_\-log().

Referenced by log\_\-call().\hypertarget{logger_8c_c5780f57248a4e80eb50e695b593a1a0}{
\index{logger.c@{logger.c}!private\_\-write\_\-log@{private\_\-write\_\-log}}
\index{private\_\-write\_\-log@{private\_\-write\_\-log}!logger.c@{logger.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void private\_\-write\_\-log (int {\em log\_\-type}, \/  const char $\ast$ {\em msg})}}
\label{logger_8c_c5780f57248a4e80eb50e695b593a1a0}


Permet d'écrire le log d'un message passé, suivant le type de log. Il n'est pas conseillé d'appeler cetter fonction directement! Passez plutôt par \char`\"{}log\char`\"{} qui s'occupe de tout. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em log\_\-type}]type de log, voir l'enum plus haut \item[{\em msg}]le message à être loggué \end{description}
\end{Desc}


Definition at line 47 of file logger.c.

References call\_\-type, comm\_\-type, filename, and msg\_\-type.

Referenced by log\_\-msg(), log\_\-smth(), log\_\-srv(), and private\_\-log\_\-call().

\subsection{Variable Documentation}
\hypertarget{logger_8c_eac90097f29f7529968697163cea5c18}{
\index{logger.c@{logger.c}!filename@{filename}}
\index{filename@{filename}!logger.c@{logger.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ {\bf filename} = NULL}}
\label{logger_8c_eac90097f29f7529968697163cea5c18}




Definition at line 3 of file logger.c.

Referenced by init\_\-log(), and private\_\-write\_\-log().